/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.escom.healthlc.controller;

import com.escom.healthlc.business.EnfermedadBusiness;
import com.escom.healthlc.entidad.EnfermedadVO;
import com.escom.healthlc.utils.Constantes;
import com.escom.healthlc.utils.LazySorterEnfermedad;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.event.ComponentSystemEvent;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.primefaces.event.SelectEvent;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author LAURA
 */
@ManagedBean(name = "EnfermedadController")
@ViewScoped
public class EnfermedadController {

    private static final Logger logger = LoggerFactory.getLogger(EnfermedadController.class);

    private List<EnfermedadVO> retrieveEnfermedad;
    private EnfermedadVO selectedEnfermedad;
    private EnfermedadVO createEnfermedad;
    private EnfermedadVO enfermedadCurrent;
    private LazyDataModel<EnfermedadVO> modelEnfermedad;
    private boolean renderPanelAlta;
    private boolean renderPanelConsulta;
    private boolean pageComplete;

    @ManagedProperty("#{EnfermedadBusiness}")
    private EnfermedadBusiness enfermedadBusiness;

    public EnfermedadController() {
    }

    @PostConstruct
    private void initEnfermedadController() {
        executeLimpiarObejects(null);
    }

    public void executeCrearEnfermedad(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        enfermedadBusiness.crearEnfermedad(createEnfermedad);
        int estado = enfermedadBusiness.getEstado();
        String messageEstado = enfermedadBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_ERROR, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }

        executeLimpiarObejects(acEvt);
    }

    public void executeConsultarEnfermedad(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        retrieveEnfermedad = enfermedadBusiness.obtenerEnfermedad();
        logger.debug("Size {}", retrieveEnfermedad.size());

        if (retrieveEnfermedad == null) {
            retrieveEnfermedad = new ArrayList<EnfermedadVO>();
        }
        modelEnfermedad = crearLazyModelEnfermedad();
        int estado = enfermedadBusiness.getEstado();
        String messageEstado = enfermedadBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeChangeToRetrieve();
    }

    public void executeActualizarEnfermedad(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        enfermedadBusiness.actualizarEnfermedad(selectedEnfermedad);
        int estado = enfermedadBusiness.getEstado();
        String messageEstado = enfermedadBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, messageEstado, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, messageEstado, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeLimpiarObejects(acEvt);
    }

    public void executeEliminarEnfermedad(ActionEvent acEvt) {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        FacesMessage facesMessage;
        enfermedadBusiness.eliminarEnfermedad(selectedEnfermedad);
        int estado = enfermedadBusiness.getEstado();
        String messageEstado = enfermedadBusiness.getMessageEstado();
        switch (estado) {
            case Constantes.SIN_ERROR:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_INFO, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
            case Constantes.ERROR_BASE_DATOS:
                facesMessage = new FacesMessage(FacesMessage.SEVERITY_ERROR, Constantes.MESSAGE_TITLE, messageEstado);
                facesContext.addMessage(null, facesMessage);
                break;
        }
        executeLimpiarObejects(acEvt);
    }

    private LazyDataModel<EnfermedadVO> crearLazyModelEnfermedad() {
        LazyDataModel<EnfermedadVO> lazyDataReturn = new LazyDataModel<EnfermedadVO>() {
            List<EnfermedadVO> datasource = retrieveEnfermedad;

            @Override
            public EnfermedadVO getRowData(String rowKey) {
                for (EnfermedadVO enfermedad : datasource) {
                    if (enfermedad.getEnfermedad().equals(rowKey)) {
                        return enfermedad;
                    }
                }
                return null;
            }

            @Override
            public List<EnfermedadVO> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String, String> filters) {
                List<EnfermedadVO> data = new ArrayList<>();

                //filter  
                for (EnfermedadVO enfermedad : datasource) {
                    boolean match = true;
                    for (Iterator<String> it = filters.keySet().iterator(); it.hasNext();) {
                        try {
                            String filterProperty = it.next();
                            Field field;
                            String filterValue = "";
                            String fieldValue;
                            field = enfermedad.getClass().getDeclaredField(filterProperty);
                            field.setAccessible(true);
                            filterValue = filters.get(filterProperty);
                            fieldValue = String.valueOf(field.get(enfermedad));

                            if (filterValue == null || fieldValue.contains(filterValue)) {
                                match = true;
                            } else {
                                match = false;
                                break;
                            }
                        } catch (Exception e) {
                            match = false;
                        }
                    }

                    if (match) {
                        data.add(enfermedad);
                    }
                }

//                sort  
                if (sortField != null) {
                    Collections.sort(data, new LazySorterEnfermedad(sortField, sortOrder));
                }
                if (sortField == null) {
                    sortField = "defaultSortField";
                }
                //rowCount  
                int dataSize = data.size();
                this.setRowCount(dataSize);

                //paginate  
                if (dataSize > pageSize) {
                    try {
                        return data.subList(first, first + pageSize);
                    } catch (IndexOutOfBoundsException e) {
                        return data.subList(first, first + (dataSize % pageSize));
                    }
                } else {
                    return data;
                }
            }

            @Override
            public Object getRowKey(EnfermedadVO t) {
                return t.getIdEnfermedad();
            }
        };
        return lazyDataReturn;
    }

    public void executeLimpiarObejects(ActionEvent acEvt) {
        retrieveEnfermedad = new ArrayList<>();
        createEnfermedad = new EnfermedadVO();
        renderPanelAlta = false;
        renderPanelConsulta = false;
    }

    public void executeChangeToCreate() {
        renderPanelAlta = true;
        renderPanelConsulta = false;
    }

    public void executeChangeToRetrieve() {
        renderPanelAlta = false;
        renderPanelConsulta = true;
    }

    public boolean isRenderPanelAlta() {
        return renderPanelAlta;
    }

    public void setRenderPanelAlta(boolean renderPanelAlta) {
        this.renderPanelAlta = renderPanelAlta;
    }

    public boolean isRenderPanelConsulta() {
        return renderPanelConsulta;
    }

    public void setRenderPanelConsulta(boolean renderPanelConsulta) {
        this.renderPanelConsulta = renderPanelConsulta;
    }

    public EnfermedadVO getSelectedEnfermedad() {
        return selectedEnfermedad;
    }

    public void setSelectedEnfermedad(EnfermedadVO selectedEnfermedad) {
        this.selectedEnfermedad = selectedEnfermedad;
    }

    public EnfermedadVO getCreateEnfermedad() {
        return createEnfermedad;
    }

    public void setCreateEnfermedad(EnfermedadVO createEnfermedad) {
        this.createEnfermedad = createEnfermedad;
    }

    public LazyDataModel<EnfermedadVO> getModelEnfermedad() {
        return modelEnfermedad;
    }

    public void setModelEnfermedad(LazyDataModel<EnfermedadVO> modelEnfermedad) {
        this.modelEnfermedad = modelEnfermedad;
    }

    public EnfermedadBusiness getEnfermedadBusiness() {
        return enfermedadBusiness;
    }

    public void setEnfermedadBusiness(EnfermedadBusiness enfermedadBusiness) {
        this.enfermedadBusiness = enfermedadBusiness;
    }

}
